home *** CD-ROM | disk | FTP | other *** search
/ Deutsche Edition 1 / Deutsche Edition 1.iso / amok / 061-070 / amok66 / speed / speedtest.mod < prev    next >
Text File  |  1993-11-04  |  6KB  |  183 lines
  1. (* ------------------------------------------------------------------------
  2.   :Program.     SpeedTest.
  3.   :Contents.    Proceduren zum Zeittest von 'Copy' u.a. aus Speed.
  4.   :Author.      Klaus Hlawaty.
  5.   :Address.     Waldhof
  6.   :Address.     3579 Schrecksbach
  7.   :History.     v1.0 - 18.12.90.
  8.   :Imports.     Speed.
  9.   :Imports.     KHTime.
  10.   :Copyright.   PD
  11.   :Language.    Oberon v2.13
  12.   :Translator.  OBERON v2.13 / OLink v2.13d
  13. ------------------------------------------------------------------------ *)
  14. MODULE SpeedTest;
  15.  
  16. IMPORT
  17.          Beep,
  18.          BreakRq,
  19.          io,
  20.          KHTime,
  21.          Mouse,
  22.          NoGuruRq,
  23.       rc:RealConversions,
  24.       Rq:Requests,
  25.          Speed,            (* Wird getestet *)
  26.        s:SYSTEM;
  27.  
  28. CONST ArrM* = 40000;       (* Array größer als 32767 *)
  29.       TLoop = 100;         (* Bei TLoop = 1000, Wartezeit > 5 min *)
  30.  
  31. TYPE
  32.       StrT*  = ARRAY ArrM OF CHAR;
  33. VAR
  34.       x1*,
  35.       x2* : StrT;
  36.       z1*,
  37.       z2* : INTEGER;
  38.  
  39.       t1, t2 : KHTime.TTime;
  40.       r      : REAL;
  41.       Str    : ARRAY 30 OF CHAR;
  42.  
  43.       Trenn  : ARRAY 80 OF CHAR;
  44.  
  45. BEGIN
  46.    BreakRq.CtrlCOn;
  47.    io.WriteString("Das Program benutzt zwei Array's 'x1' und 'x2' mit einer\n");
  48.    io.WriteString("Länge von jeweils 40000 Bytes\n");
  49.    io.WriteString("Alle Schleifen werden TLoop =");
  50.    io.WriteInt   (TLoop,6);
  51.    io.WriteString("mal wiederholt\n");
  52.    Speed.FillC("=",70,Trenn); Trenn[70] := "\n";
  53.    io.WriteString(Trenn);
  54.    io.WriteString("Hier erfolgt eine Zuweistung x2 := x1:\n");
  55.    io.WriteString("Normal:");
  56.    KHTime.GetTime(t1);
  57.    z1 := 0;
  58.    REPEAT
  59.       (* $NilChk- $OvflChk- $RangeChk- *)
  60.       x2 := x1;
  61.       (* $NilChk= $OvflChk= $RangeChk= *)
  62.       INC(z1);
  63.    UNTIL z1 >= TLoop;
  64.    KHTime.GetTime(t2);
  65.    Beep.Beep(TRUE);
  66.    r := (t2.ATicks-t1.ATicks)/50;
  67.    Rq.Assert(rc.RealToString(r,Str,5,3,FALSE),"RealConv: Fehler");
  68.    io.WriteString(Str);
  69.    io.WriteString(" sec's\n");
  70.    io.WriteString("Speed :");
  71.    KHTime.GetTime(t1);
  72.    z1 := 0;
  73.    REPEAT
  74.       Speed.Copy(x1[0],x2[0],ArrM);
  75.       (* Durch Angabe des 1.Index erfolgt ein Zugriff auf         *)
  76.       (* ein Array größer 32767 !!                                *)
  77.       (* -------------------------------------------------------- *)
  78.       INC(z1);
  79.    UNTIL z1 >= TLoop;
  80.    KHTime.GetTime(t2);
  81.    r := (t2.ATicks-t1.ATicks)/50;
  82.    Rq.Assert(rc.RealToString(r,Str,5,3,FALSE),"RealConv: Fehler");
  83.    io.WriteString(Str);
  84.    io.WriteString(" sec's\n");
  85.    Beep.Beep(TRUE);
  86.    Speed.FillC("-",70,Trenn); Trenn[70] := "\n";
  87.    io.WriteString(Trenn);
  88.    io.WriteString("Hier werden 10000 Bytes von x1 nach x2 kopiert\n");
  89.    io.WriteString("1.) Normal : x2[z2] := x1[z1]\n");
  90.    io.WriteString("2.) Chk-   : wie oben mit $NilChk- $OvflChk- $RangeChk-\n");
  91.    io.WriteString("3.) Speed  : Kopiert x1[5000] nach x2[15000] volle Geschwindigkeit\n");
  92.    io.WriteString("4.) Speed  : Kopiert x1[1](ungerade) nach x2[2](gerade) Byteweise\n");
  93.    io.WriteString("1.) Normal (10000Byte):");
  94.    KHTime.GetTime(t1);
  95.    z1 := 0;
  96.    REPEAT
  97.       z2 := 1;
  98.       REPEAT
  99.          x2[z2] := x1[z2];
  100.          INC(z2);
  101.       UNTIL(z2 > 10001);
  102.       INC(z1);
  103.    UNTIL z1 >= TLoop;
  104.    KHTime.GetTime(t2);
  105.    Beep.Beep(TRUE);
  106.    r := (t2.ATicks-t1.ATicks)/50;
  107.    Rq.Assert(rc.RealToString(r,Str,5,3,FALSE),"RealConv: Fehler");
  108.    io.WriteString(Str);
  109.    io.WriteString(" sec's\n");
  110.    io.WriteString("2.) Chk-   (10000Byte):");
  111.    (* Hier erfolgt der Zugriff mit abgeschalteten Überprüfungen *)
  112.    KHTime.GetTime(t1);
  113.    z1 := 0;
  114.    (* $NilChk- $OvflChk- $RangeChk- *)
  115.    REPEAT
  116.       z2 := 10000;
  117.       REPEAT
  118.          x2[z2] := x1[z2];
  119.          INC(z2);
  120.       UNTIL(z2 > 20001);
  121.       INC(z1);
  122.    UNTIL z1 >= TLoop;
  123.    (* $NilChk= $OvflChk= $RangeChk= *)
  124.    KHTime.GetTime(t2);
  125.    Beep.Beep(TRUE);
  126.    r := (t2.ATicks-t1.ATicks)/50;
  127.    Rq.Assert(rc.RealToString(r,Str,5,3,FALSE),"RealConv: Fehler");
  128.    io.WriteString(Str);
  129.    io.WriteString(" sec's\n");
  130.    io.WriteString("3.) Speed  (10000/48 ):");
  131.    KHTime.GetTime(t1);
  132.    z1 := 0;
  133.    REPEAT
  134.       Speed.Copy(x1[5000],x2[15000],10000);
  135.       (* -------------------------------------------------------- *)
  136.       (* Copiert von x1Ptr Index 5000 auf x2Ptr Index 15000       *)
  137.       (* insgesamt 10000 Bytes !!                                 *)
  138.       (* Dieser Transfer ist komplexer als die obigen Beispiele   *)
  139.       (* Andererseits werden oben Bytes copiert, während in       *)
  140.       (* Speed.Copy gleichzeitig bis zu 48 Bytes in zwei Befehlen *)
  141.       (* bewegt werden.                                           *)
  142.       (* -------------------------------------------------------- *)
  143.       INC(z1);
  144.    UNTIL z1 >= TLoop;
  145.    KHTime.GetTime(t2);
  146.    r := (t2.ATicks-t1.ATicks)/50;
  147.    Rq.Assert(rc.RealToString(r,Str,5,3,FALSE),"RealConv: Fehler");
  148.    io.WriteString(Str);
  149.    io.WriteString(" sec's");
  150.    io.WriteLn;
  151.    io.WriteString("4.) Speed  (10000Byte):");
  152.    KHTime.GetTime(t1);
  153.    z1 := 0;
  154.    REPEAT
  155.       Speed.Copy(x1[1],x2[2],10000);
  156.       (* -------------------------------------------------------- *)
  157.       (* Copiert von x1Ptr Index 1 auf x2Ptr Index 2              *)
  158.       (* insgesamt 10000 Bytes hierbei wird durch die Verwendung  *)
  159.       (* einer geraden (1) und einer ungeraden (2) Addresse eine  *)
  160.       (* byteweises Kopieren erzwungen.                           *)
  161.       (* Da die Indexzählung mit 0 beginnt ist Index 1 gerade und *)
  162.       (* Index 2 ungerade !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!  *)
  163.       (* -------------------------------------------------------- *)
  164.       INC(z1);
  165.    UNTIL z1 >= TLoop;
  166.    KHTime.GetTime(t2);
  167.    r := (t2.ATicks-t1.ATicks)/50;
  168.    Rq.Assert(rc.RealToString(r,Str,5,3,FALSE),"RealConv: Fehler");
  169.    io.WriteString(Str);
  170.    io.WriteString(" sec's");
  171.    io.WriteLn;
  172.    Beep.Beep(TRUE);
  173.  
  174. CLOSE
  175.    Beep.Beep(FALSE);
  176.    Beep.Beep(TRUE);
  177.    Beep.Beep(FALSE);
  178.    Speed.FillC("=",70,Trenn); Trenn[70] := "\n";
  179.    io.WriteString(Trenn);
  180.    io.WriteString("\n Rechte Mausetaste !!!!!!!!! \n");
  181.    REPEAT UNTIL Mouse.rightButton;
  182. END SpeedTest.
  183.